package name.peter.leetcode.daily.minlengofconcatenatedisomorphicstrs;

import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 给你一个字符串 s ，它由某个字符串 t 和若干 t  的 同位字符串 连接而成。
 *
 * 请你返回字符串 t 的 最小 可能长度。
 *
 * 同位字符串 指的是重新排列一个单词得到的另外一个字符串，原来字符串中的每个字符在新字符串中都恰好只使用一次。
 */
public class Solution {
    public int minAnagramLength(String s) {
        int count = s.length();
        Set<Character> charSet = s.chars()  // 将字符串转换为字符流
                .mapToObj(c -> (char) c)  // 将基本类型int转换为Character对象
                .collect(Collectors.toSet());  // 收集到Set中，自动去重
        int begin = charSet.size();
        for (int i = begin; i < count; i++) {
            if (count % i == 0) {
                // 把字符串分割成若干个数组
                String[] arr = splitStringIntoParts(s, i);
                // 获取每个数组的每个字符的数量，用map表示
                // 单独提出第一个
                Map<Character, Integer> map = arr[0].chars()
                        .mapToObj(c -> (char) c)
                        .collect(Collectors.toMap(
                                c -> c,
                                c -> 1,
                                Integer::sum));
                boolean isRet = true;
                for (int j = 1; j < arr.length; j++) {
                    Map<Character, Integer> map1 = arr[j].chars()
                            .mapToObj(c -> (char) c)
                            .collect(Collectors.toMap(
                                    c -> c,
                                    c -> 1,
                                    Integer::sum));
                    // 两个map每个key的value进行比较
                    boolean isSame = true;
                    for (Character character : map.keySet()) {
                        if (map.get(character) != map1.get(character)) {
                            isSame = false;
                            break;
                        }
                    }

                    // 存在对不上的，修改isRet
                    if (!isSame) {
                        isRet = false;
                        break;
                    }
                }

                if (isRet) return i;
            }
        }
        return count;
    }

    /**
     * 将给定的字符串分割成指定长度的多个部分
     *
     * @param str       要分割的字符串
     * @param partLength 每个部分的长度
     * @return 分割后的字符串数组
     */
    private String[] splitStringIntoParts(String str, int partLength) {
        // 计算需要多少个部分
        int partsCount = (str.length() + partLength - 1) / partLength; // 向上取整
        String[] parts = new String[partsCount];

        // 循环分割字符串
        for (int i = 0; i < partsCount; i++) {
            int start = i * partLength;
            int end = Math.min(start + partLength, str.length()); // 防止越界
            parts[i] = str.substring(start, end);
        }

        return parts;
    }

    public static void main(String[] args) {
        System.out.println(new Solution().minAnagramLength("abba"));
    }
}
